package com.ourteam.education.dao;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;
/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2019-09-22 15:15:07
  * Warning ! This file will be overwrite when regenerate !
  * 
 */
public class CourseDefineDAOQueryBean extends BaseQueryBean {
    
    public CourseDefineDAOQueryBean() {
		super();
    }
	
    public CourseDefineDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }
    
    public CourseDefineDAOQueryBean(BaseQueryBean aQueryBean,Map tableReplaceMap) {
        super(aQueryBean,tableReplaceMap);
    }
    
    public Criteria createCriteria() {
        
	    Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
                  oredCriteria.add(criteria);
            }
        return criteria;
     }
	
    protected Criteria createCriteriaInternal() {
	  return new Criteria(this);
    }
    
        
        
    	
		
	    
    public void addIdSelectProperty(){
		addIdSelectProperty("id");
	}
	
    public void addIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.Id,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.Id,"id");
	    }
    }
    
       
		
		
	    
    public void addCourseTypeIdSelectProperty(){
		addCourseTypeIdSelectProperty("courseTypeId");
	}
	
    public void addCourseTypeIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.CourseTypeId,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.CourseTypeId,"courseTypeId");
	    }
    }
    
       
		
		
	    
    public void addCourseNameSelectProperty(){
		addCourseNameSelectProperty("courseName");
	}
	
    public void addCourseNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.CourseName,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.CourseName,"courseName");
	    }
    }
    
       
		
		
	    
    public void addSchoolYearSelectProperty(){
		addSchoolYearSelectProperty("schoolYear");
	}
	
    public void addSchoolYearSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.SchoolYear,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.SchoolYear,"schoolYear");
	    }
    }
    
       
		
		
	    
    public void addTeachingModeSelectProperty(){
		addTeachingModeSelectProperty("teachingMode");
	}
	
    public void addTeachingModeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.TeachingMode,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.TeachingMode,"teachingMode");
	    }
    }
    
       
		
		
	    
    public void addChargingModeSelectProperty(){
		addChargingModeSelectProperty("chargingMode");
	}
	
    public void addChargingModeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.ChargingMode,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.ChargingMode,"chargingMode");
	    }
    }
    
       
		
		
	    
    public void addStatusSelectProperty(){
		addStatusSelectProperty("status");
	}
	
    public void addStatusSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.Status,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.Status,"status");
	    }
    }
    
       
		
		
	    
    public void addRemarksSelectProperty(){
		addRemarksSelectProperty("remarks");
	}
	
    public void addRemarksSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.Remarks,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.Remarks,"remarks");
	    }
    }
    
       
		
		
	    
    public void addDeleteFlagSelectProperty(){
		addDeleteFlagSelectProperty("deleteFlag");
	}
	
    public void addDeleteFlagSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.DeleteFlag,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.DeleteFlag,"deleteFlag");
	    }
    }
    
       
		
						
	    
    public void addCourseTypeNameSelectProperty(){
		addCourseTypeNameSelectProperty("courseTypeName");
	}
	
    public void addCourseTypeNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ICourseDefineDAO.CourseTypeName,aAlias);
		}
		else{
			addSelectProperty(ICourseDefineDAO.CourseTypeName,"courseTypeName");
	    }
    }
    
    	
				
	public void addAllSelectProperties(){
		
		
	    addIdSelectProperty();
   
		
		
	    addCourseTypeIdSelectProperty();
   
		
		
	    addCourseNameSelectProperty();
   
		
		
	    addSchoolYearSelectProperty();
   
		
		
	    addTeachingModeSelectProperty();
   
		
		
	    addChargingModeSelectProperty();
   
		
		
	    addStatusSelectProperty();
   
		
		
	    addRemarksSelectProperty();
   
		
		
	    addDeleteFlagSelectProperty();
   
		
						
    	addCourseTypeNameSelectProperty();
	
			    }
    
    public static class Criteria extends BaseWhereCriterion<CourseDefineDAOQueryBean> {
	
        protected Criteria(CourseDefineDAOQueryBean aParentObject) {
		    super(aParentObject);
        }
        
                  
            	
    	    	
    	        
                
        public Criteria andIdIsNull() {
            addCriterion(ICourseDefineDAO.Id + " is null");
            return this;
        }
        public Criteria andIdIsNotNull() {
            addCriterion(ICourseDefineDAO.Id + " is not null");
            return this;
        }
    
        public Criteria andIdIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.Id + " is not null AND " + ICourseDefineDAO.Id + " <> ''");
            return this;
        }
    		
    	public Criteria andIdIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.Id + " is null OR " + ICourseDefineDAO.Id + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andIdEqualTo(long value) {
        	return andIdEqualTo(Long.valueOf(value));
        }
               public Criteria andIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.Id + " = ", value, "id");
            return this;
        }
        
        public Criteria andIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andIdNotEqualTo(long value) {
        	return andIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ICourseDefineDAO.Id + " <>", value, "id");
            return this;
        }
               
        public Criteria andIdNotEqualToOrIsNull(long value) {
        	return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ICourseDefineDAO.Id + " is null OR " + ICourseDefineDAO.Id + " <>", value, "id");
            return this;
        }
        
        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThan(long value) {
        	return andIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.Id + " >", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThanOrEqualTo(long value) {
        	return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.Id + " >=", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThan(long value) {
        	return andIdLessThan(Long.valueOf(value));
        }
                public Criteria andIdLessThan(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.Id + " <", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThanOrEqualTo(long value) {
        	return andIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.Id + " <=", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Id);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andIdIn(long[] values) {
        	if(values.length == 1){
        		return andIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
                public Criteria andIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " in", values, "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " in", Arrays.asList(values), "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Id + " not in", Arrays.asList(values), "id");
            	return this;
            }
        }
		
		public Criteria andIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Id + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdBetween(long value1,long value2) {
        	addCriterion(ICourseDefineDAO.Id + " between", value1, value2, "id");
            return this;
        }
                public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ICourseDefineDAO.Id + " between", value1, value2, "id");
            return this;
        }
        
                
        public Criteria andIdNotBetween(long value1,long value2) {
        	addCriterion(ICourseDefineDAO.Id + " not between", value1, value2, "id");
            return this;
        }
                public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ICourseDefineDAO.Id + " not between", value1, value2, "id");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andCourseTypeIdIsNull() {
            addCriterion(ICourseDefineDAO.CourseTypeId + " is null");
            return this;
        }
        public Criteria andCourseTypeIdIsNotNull() {
            addCriterion(ICourseDefineDAO.CourseTypeId + " is not null");
            return this;
        }
    
        public Criteria andCourseTypeIdIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.CourseTypeId + " is not null AND " + ICourseDefineDAO.CourseTypeId + " <> ''");
            return this;
        }
    		
    	public Criteria andCourseTypeIdIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.CourseTypeId + " is null OR " + ICourseDefineDAO.CourseTypeId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andCourseTypeIdEqualTo(long value) {
        	return andCourseTypeIdEqualTo(Long.valueOf(value));
        }
               public Criteria andCourseTypeIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeId + " = ", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andCourseTypeIdNotEqualTo(long value) {
        	return andCourseTypeIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseTypeIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ICourseDefineDAO.CourseTypeId + " <>", value, "courseTypeId");
            return this;
        }
               
        public Criteria andCourseTypeIdNotEqualToOrIsNull(long value) {
        	return andCourseTypeIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andCourseTypeIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ICourseDefineDAO.CourseTypeId + " is null OR " + ICourseDefineDAO.CourseTypeId + " <>", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCourseTypeIdGreaterThan(long value) {
        	return andCourseTypeIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andCourseTypeIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeId + " >", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCourseTypeIdGreaterThanOrEqualTo(long value) {
        	return andCourseTypeIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseTypeIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeId + " >=", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseTypeIdLessThan(long value) {
        	return andCourseTypeIdLessThan(Long.valueOf(value));
        }
                public Criteria andCourseTypeIdLessThan(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeId + " <", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseTypeIdLessThanOrEqualTo(long value) {
        	return andCourseTypeIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseTypeIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeId + " <=", value, "courseTypeId");
            return this;
        }
        
        public Criteria andCourseTypeIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andCourseTypeIdIn(long[] values) {
        	if(values.length == 1){
        		return andCourseTypeIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " in", values, "courseTypeId");
            	return this;
            }
        }
        
        public Criteria andCourseTypeIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andCourseTypeIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " not in", values, "courseTypeId");
            	return this;
            }
        }
        
                public Criteria andCourseTypeIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andCourseTypeIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " in", values, "courseTypeId");
            	return this;
            }
        }
        public Criteria andCourseTypeIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andCourseTypeIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " not in", values, "courseTypeId");
            	return this;
            }
        }
        
        public Criteria andCourseTypeIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andCourseTypeIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " in", Arrays.asList(values), "courseTypeId");
            	return this;
            }
        }
        public Criteria andCourseTypeIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andCourseTypeIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeId + " not in", Arrays.asList(values), "courseTypeId");
            	return this;
            }
        }
		
		public Criteria andCourseTypeIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCourseTypeIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseTypeIdBetween(long value1,long value2) {
        	addCriterion(ICourseDefineDAO.CourseTypeId + " between", value1, value2, "courseTypeId");
            return this;
        }
                public Criteria andCourseTypeIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ICourseDefineDAO.CourseTypeId + " between", value1, value2, "courseTypeId");
            return this;
        }
        
                
        public Criteria andCourseTypeIdNotBetween(long value1,long value2) {
        	addCriterion(ICourseDefineDAO.CourseTypeId + " not between", value1, value2, "courseTypeId");
            return this;
        }
                public Criteria andCourseTypeIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ICourseDefineDAO.CourseTypeId + " not between", value1, value2, "courseTypeId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andCourseNameIsNull() {
            addCriterion(ICourseDefineDAO.CourseName + " is null");
            return this;
        }
        public Criteria andCourseNameIsNotNull() {
            addCriterion(ICourseDefineDAO.CourseName + " is not null");
            return this;
        }
    
        public Criteria andCourseNameIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.CourseName + " is not null AND " + ICourseDefineDAO.CourseName + " <> ''");
            return this;
        }
    		
    	public Criteria andCourseNameIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.CourseName + " is null OR " + ICourseDefineDAO.CourseName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andCourseNameEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseName + " = ", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andCourseNameNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.CourseName + " <>", value, "courseName");
            return this;
        }
               
        public Criteria andCourseNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.CourseName + " is null OR " + ICourseDefineDAO.CourseName + " <>", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseNameGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseName + " >", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseName + " >=", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseName + " <", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseName + " <=", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andCourseNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.CourseName + " like", buffer.toString(), "courseName");
            return this;
        }
        public Criteria andCourseNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.CourseName + " not like", buffer.toString(), "courseName");
            return this;
        }
                
                public Criteria andCourseNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andCourseNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseName + " in", values, "courseName");
            	return this;
            }
        }
        public Criteria andCourseNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andCourseNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseName + " not in", values, "courseName");
            	return this;
            }
        }
        
        public Criteria andCourseNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andCourseNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseName + " in", Arrays.asList(values), "courseName");
            	return this;
            }
        }
        public Criteria andCourseNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andCourseNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseName + " not in", Arrays.asList(values), "courseName");
            	return this;
            }
        }
		
		public Criteria andCourseNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCourseNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.CourseName + " between", value1, value2, "courseName");
            return this;
        }
        
                public Criteria andCourseNameNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.CourseName + " not between", value1, value2, "courseName");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andSchoolYearIsNull() {
            addCriterion(ICourseDefineDAO.SchoolYear + " is null");
            return this;
        }
        public Criteria andSchoolYearIsNotNull() {
            addCriterion(ICourseDefineDAO.SchoolYear + " is not null");
            return this;
        }
    
        public Criteria andSchoolYearIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.SchoolYear + " is not null AND " + ICourseDefineDAO.SchoolYear + " <> ''");
            return this;
        }
    		
    	public Criteria andSchoolYearIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.SchoolYear + " is null OR " + ICourseDefineDAO.SchoolYear + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andSchoolYearEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.SchoolYear + " = ", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andSchoolYearNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.SchoolYear + " <>", value, "schoolYear");
            return this;
        }
               
        public Criteria andSchoolYearNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.SchoolYear + " is null OR " + ICourseDefineDAO.SchoolYear + " <>", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andSchoolYearGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.SchoolYear + " >", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andSchoolYearGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.SchoolYear + " >=", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andSchoolYearLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.SchoolYear + " <", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andSchoolYearLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.SchoolYear + " <=", value, "schoolYear");
            return this;
        }
        
        public Criteria andSchoolYearLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.SchoolYear);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSchoolYearLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andSchoolYearLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.SchoolYear + " like", buffer.toString(), "schoolYear");
            return this;
        }
        public Criteria andSchoolYearNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.SchoolYear + " not like", buffer.toString(), "schoolYear");
            return this;
        }
                
                public Criteria andSchoolYearIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andSchoolYearEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.SchoolYear + " in", values, "schoolYear");
            	return this;
            }
        }
        public Criteria andSchoolYearNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andSchoolYearNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.SchoolYear + " not in", values, "schoolYear");
            	return this;
            }
        }
        
        public Criteria andSchoolYearIn(String[] values) {
        	
        	if(values.length == 1){
        		return andSchoolYearEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.SchoolYear + " in", Arrays.asList(values), "schoolYear");
            	return this;
            }
        }
        public Criteria andSchoolYearNotIn(String[] values) {
        	if(values.length == 1){
        		return andSchoolYearNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.SchoolYear + " not in", Arrays.asList(values), "schoolYear");
            	return this;
            }
        }
		
		public Criteria andSchoolYearIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andSchoolYearNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.SchoolYear + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andSchoolYearBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.SchoolYear + " between", value1, value2, "schoolYear");
            return this;
        }
        
                public Criteria andSchoolYearNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.SchoolYear + " not between", value1, value2, "schoolYear");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andTeachingModeIsNull() {
            addCriterion(ICourseDefineDAO.TeachingMode + " is null");
            return this;
        }
        public Criteria andTeachingModeIsNotNull() {
            addCriterion(ICourseDefineDAO.TeachingMode + " is not null");
            return this;
        }
    
        public Criteria andTeachingModeIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.TeachingMode + " is not null AND " + ICourseDefineDAO.TeachingMode + " <> ''");
            return this;
        }
    		
    	public Criteria andTeachingModeIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.TeachingMode + " is null OR " + ICourseDefineDAO.TeachingMode + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andTeachingModeEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.TeachingMode + " = ", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andTeachingModeNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.TeachingMode + " <>", value, "teachingMode");
            return this;
        }
               
        public Criteria andTeachingModeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.TeachingMode + " is null OR " + ICourseDefineDAO.TeachingMode + " <>", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeachingModeGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.TeachingMode + " >", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeachingModeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.TeachingMode + " >=", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeachingModeLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.TeachingMode + " <", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeachingModeLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.TeachingMode + " <=", value, "teachingMode");
            return this;
        }
        
        public Criteria andTeachingModeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.TeachingMode);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeachingModeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andTeachingModeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.TeachingMode + " like", buffer.toString(), "teachingMode");
            return this;
        }
        public Criteria andTeachingModeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.TeachingMode + " not like", buffer.toString(), "teachingMode");
            return this;
        }
                
                public Criteria andTeachingModeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andTeachingModeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.TeachingMode + " in", values, "teachingMode");
            	return this;
            }
        }
        public Criteria andTeachingModeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andTeachingModeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.TeachingMode + " not in", values, "teachingMode");
            	return this;
            }
        }
        
        public Criteria andTeachingModeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andTeachingModeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.TeachingMode + " in", Arrays.asList(values), "teachingMode");
            	return this;
            }
        }
        public Criteria andTeachingModeNotIn(String[] values) {
        	if(values.length == 1){
        		return andTeachingModeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.TeachingMode + " not in", Arrays.asList(values), "teachingMode");
            	return this;
            }
        }
		
		public Criteria andTeachingModeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeachingModeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.TeachingMode + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeachingModeBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.TeachingMode + " between", value1, value2, "teachingMode");
            return this;
        }
        
                public Criteria andTeachingModeNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.TeachingMode + " not between", value1, value2, "teachingMode");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andChargingModeIsNull() {
            addCriterion(ICourseDefineDAO.ChargingMode + " is null");
            return this;
        }
        public Criteria andChargingModeIsNotNull() {
            addCriterion(ICourseDefineDAO.ChargingMode + " is not null");
            return this;
        }
    
        public Criteria andChargingModeIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.ChargingMode + " is not null AND " + ICourseDefineDAO.ChargingMode + " <> ''");
            return this;
        }
    		
    	public Criteria andChargingModeIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.ChargingMode + " is null OR " + ICourseDefineDAO.ChargingMode + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andChargingModeEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.ChargingMode + " = ", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andChargingModeNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.ChargingMode + " <>", value, "chargingMode");
            return this;
        }
               
        public Criteria andChargingModeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.ChargingMode + " is null OR " + ICourseDefineDAO.ChargingMode + " <>", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andChargingModeGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.ChargingMode + " >", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andChargingModeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.ChargingMode + " >=", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andChargingModeLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.ChargingMode + " <", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andChargingModeLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.ChargingMode + " <=", value, "chargingMode");
            return this;
        }
        
        public Criteria andChargingModeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.ChargingMode);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andChargingModeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andChargingModeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.ChargingMode + " like", buffer.toString(), "chargingMode");
            return this;
        }
        public Criteria andChargingModeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.ChargingMode + " not like", buffer.toString(), "chargingMode");
            return this;
        }
                
                public Criteria andChargingModeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andChargingModeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.ChargingMode + " in", values, "chargingMode");
            	return this;
            }
        }
        public Criteria andChargingModeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andChargingModeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.ChargingMode + " not in", values, "chargingMode");
            	return this;
            }
        }
        
        public Criteria andChargingModeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andChargingModeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.ChargingMode + " in", Arrays.asList(values), "chargingMode");
            	return this;
            }
        }
        public Criteria andChargingModeNotIn(String[] values) {
        	if(values.length == 1){
        		return andChargingModeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.ChargingMode + " not in", Arrays.asList(values), "chargingMode");
            	return this;
            }
        }
		
		public Criteria andChargingModeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andChargingModeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.ChargingMode + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andChargingModeBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.ChargingMode + " between", value1, value2, "chargingMode");
            return this;
        }
        
                public Criteria andChargingModeNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.ChargingMode + " not between", value1, value2, "chargingMode");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andStatusIsNull() {
            addCriterion(ICourseDefineDAO.Status + " is null");
            return this;
        }
        public Criteria andStatusIsNotNull() {
            addCriterion(ICourseDefineDAO.Status + " is not null");
            return this;
        }
    
        public Criteria andStatusIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.Status + " is not null AND " + ICourseDefineDAO.Status + " <> ''");
            return this;
        }
    		
    	public Criteria andStatusIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.Status + " is null OR " + ICourseDefineDAO.Status + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andStatusEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Status + " = ", value, "status");
            return this;
        }
        
        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andStatusNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.Status + " <>", value, "status");
            return this;
        }
               
        public Criteria andStatusNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.Status + " is null OR " + ICourseDefineDAO.Status + " <>", value, "status");
            return this;
        }
        
        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.Status + " >", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Status + " >=", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.Status + " <", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Status + " <=", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Status);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andStatusLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.Status + " like", buffer.toString(), "status");
            return this;
        }
        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.Status + " not like", buffer.toString(), "status");
            return this;
        }
                
                public Criteria andStatusIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andStatusEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Status + " in", values, "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andStatusNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Status + " not in", values, "status");
            	return this;
            }
        }
        
        public Criteria andStatusIn(String[] values) {
        	
        	if(values.length == 1){
        		return andStatusEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Status + " in", Arrays.asList(values), "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(String[] values) {
        	if(values.length == 1){
        		return andStatusNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Status + " not in", Arrays.asList(values), "status");
            	return this;
            }
        }
		
		public Criteria andStatusIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Status + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.Status + " between", value1, value2, "status");
            return this;
        }
        
                public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.Status + " not between", value1, value2, "status");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andRemarksIsNull() {
            addCriterion(ICourseDefineDAO.Remarks + " is null");
            return this;
        }
        public Criteria andRemarksIsNotNull() {
            addCriterion(ICourseDefineDAO.Remarks + " is not null");
            return this;
        }
    
        public Criteria andRemarksIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.Remarks + " is not null AND " + ICourseDefineDAO.Remarks + " <> ''");
            return this;
        }
    		
    	public Criteria andRemarksIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.Remarks + " is null OR " + ICourseDefineDAO.Remarks + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andRemarksEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Remarks + " = ", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andRemarksNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.Remarks + " <>", value, "remarks");
            return this;
        }
               
        public Criteria andRemarksNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.Remarks + " is null OR " + ICourseDefineDAO.Remarks + " <>", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.Remarks + " >", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Remarks + " >=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.Remarks + " <", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.Remarks + " <=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.Remarks);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andRemarksLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.Remarks + " like", buffer.toString(), "remarks");
            return this;
        }
        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.Remarks + " not like", buffer.toString(), "remarks");
            return this;
        }
                
                public Criteria andRemarksIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andRemarksEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Remarks + " in", values, "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andRemarksNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Remarks + " not in", values, "remarks");
            	return this;
            }
        }
        
        public Criteria andRemarksIn(String[] values) {
        	
        	if(values.length == 1){
        		return andRemarksEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Remarks + " in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(String[] values) {
        	if(values.length == 1){
        		return andRemarksNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.Remarks + " not in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
		
		public Criteria andRemarksIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.Remarks + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.Remarks + " between", value1, value2, "remarks");
            return this;
        }
        
                public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.Remarks + " not between", value1, value2, "remarks");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andDeleteFlagIsNull() {
            addCriterion(ICourseDefineDAO.DeleteFlag + " is null");
            return this;
        }
        public Criteria andDeleteFlagIsNotNull() {
            addCriterion(ICourseDefineDAO.DeleteFlag + " is not null");
            return this;
        }
    
        public Criteria andDeleteFlagIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.DeleteFlag + " is not null AND " + ICourseDefineDAO.DeleteFlag + " <> ''");
            return this;
        }
    		
    	public Criteria andDeleteFlagIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.DeleteFlag + " is null OR " + ICourseDefineDAO.DeleteFlag + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andDeleteFlagEqualTo(int value) {
        	return andDeleteFlagEqualTo(Integer.valueOf(value));
        }
               public Criteria andDeleteFlagEqualTo(java.lang.Integer value) {
        				
            addCriterion(ICourseDefineDAO.DeleteFlag + " = ", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andDeleteFlagNotEqualTo(int value) {
        	return andDeleteFlagNotEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagNotEqualTo(java.lang.Integer value) {
        	        
            addCriterion(ICourseDefineDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
               
        public Criteria andDeleteFlagNotEqualToOrIsNull(int value) {
        	return andDeleteFlagNotEqualToOrIsNull(Integer.valueOf(value));
        }
                
        public Criteria andDeleteFlagNotEqualToOrIsNull(java.lang.Integer value) {
        	        
            addCriterion(ICourseDefineDAO.DeleteFlag + " is null OR " + ICourseDefineDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThan(int value) {
        	return andDeleteFlagGreaterThan(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThan(java.lang.Integer value) {
        				
            addCriterion(ICourseDefineDAO.DeleteFlag + " >", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThanOrEqualTo(int value) {
        	return andDeleteFlagGreaterThanOrEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThanOrEqualTo(java.lang.Integer value) {
        				
            addCriterion(ICourseDefineDAO.DeleteFlag + " >=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThan(int value) {
        	return andDeleteFlagLessThan(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagLessThan(java.lang.Integer value) {
        				
            addCriterion(ICourseDefineDAO.DeleteFlag + " <", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThanOrEqualTo(int value) {
        	return andDeleteFlagLessThanOrEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagLessThanOrEqualTo(java.lang.Integer value) {
        				
            addCriterion(ICourseDefineDAO.DeleteFlag + " <=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.DeleteFlag);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andDeleteFlagIn(int[] values) {
        	if(values.length == 1){
        		return andDeleteFlagEqualTo((java.lang.Integer)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagNotIn(int[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo((java.lang.Integer)values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
                public Criteria andDeleteFlagIn(List<java.lang.Integer> values) {
        	
        	if(values.size() == 1){
        		return andDeleteFlagEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(List<java.lang.Integer> values) {
        	if(values.size() == 1){
        		return andDeleteFlagNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagIn(java.lang.Integer[] values) {
        	
        	if(values.length == 1){
        		return andDeleteFlagEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(java.lang.Integer[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.DeleteFlag + " not in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
		
		public Criteria andDeleteFlagIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andDeleteFlagNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.DeleteFlag + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagBetween(int value1,int value2) {
        	addCriterion(ICourseDefineDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagBetween(java.lang.Integer value1, java.lang.Integer value2) {
            addCriterion(ICourseDefineDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
        
                
        public Criteria andDeleteFlagNotBetween(int value1,int value2) {
        	addCriterion(ICourseDefineDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
            addCriterion(ICourseDefineDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
        
            	
    	    	
    	    	    	    	    	    	
                
                
        public Criteria andCourseTypeNameIsNull() {
            addCriterion(ICourseDefineDAO.CourseTypeName + " is null");
            return this;
        }
        public Criteria andCourseTypeNameIsNotNull() {
            addCriterion(ICourseDefineDAO.CourseTypeName + " is not null");
            return this;
        }
    
        public Criteria andCourseTypeNameIsNotEmpty() {        
            addCriterion(ICourseDefineDAO.CourseTypeName + " is not null AND " + ICourseDefineDAO.CourseTypeName + " <> ''");
            return this;
        }
    		
    	public Criteria andCourseTypeNameIsEmpty() {       
            addCriterion("(" + ICourseDefineDAO.CourseTypeName + " is null OR " + ICourseDefineDAO.CourseTypeName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andCourseTypeNameEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeName + " = ", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andCourseTypeNameNotEqualTo(String value) {
        	        
            addCriterion(ICourseDefineDAO.CourseTypeName + " <>", value, "courseTypeName");
            return this;
        }
               
        public Criteria andCourseTypeNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ICourseDefineDAO.CourseTypeName + " is null OR " + ICourseDefineDAO.CourseTypeName + " <>", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseTypeNameGreaterThan(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeName + " >", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseTypeNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeName + " >=", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseTypeNameLessThan(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeName + " <", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseTypeNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ICourseDefineDAO.CourseTypeName + " <=", value, "courseTypeName");
            return this;
        }
        
        public Criteria andCourseTypeNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ICourseDefineDAO.CourseTypeName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseTypeNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andCourseTypeNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.CourseTypeName + " like", buffer.toString(), "courseTypeName");
            return this;
        }
        public Criteria andCourseTypeNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ICourseDefineDAO.CourseTypeName + " not like", buffer.toString(), "courseTypeName");
            return this;
        }
                
                public Criteria andCourseTypeNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andCourseTypeNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeName + " in", values, "courseTypeName");
            	return this;
            }
        }
        public Criteria andCourseTypeNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andCourseTypeNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeName + " not in", values, "courseTypeName");
            	return this;
            }
        }
        
        public Criteria andCourseTypeNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andCourseTypeNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeName + " in", Arrays.asList(values), "courseTypeName");
            	return this;
            }
        }
        public Criteria andCourseTypeNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andCourseTypeNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ICourseDefineDAO.CourseTypeName + " not in", Arrays.asList(values), "courseTypeName");
            	return this;
            }
        }
		
		public Criteria andCourseTypeNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCourseTypeNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ICourseDefineDAO.CourseTypeName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseTypeNameBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.CourseTypeName + " between", value1, value2, "courseTypeName");
            return this;
        }
        
                public Criteria andCourseTypeNameNotBetween(String value1, String value2) {
            addCriterion(ICourseDefineDAO.CourseTypeName + " not between", value1, value2, "courseTypeName");
            return this;
        }
        
            	
    	    	    	        
        
    }
	
    
}